package com.qingke.practice2;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

/* 1.使用 = 赋值是创建了一个字符串直接量，该常量被放入常量池中，如果使用new关键字赋值，该对象会被放入堆中，而且一般使用new创建String类型
 * 变量，会创建两个字符串对象，一个是字符串直接量，另一个是字符串引用变量。
 * 
 * 2. String类是一个不可变类，一旦创建某个String对象，其值便不可改变，而StringBuffer类与String类型大致相同，但是却可以后期改变StringBuffer
 * 对象的值，同时StringBuffer类是线程安全的。
 * 
 * 3.break语句会使程序直接跳出循环，continue语句会使程序略过当前循环余下的语句，直接执行下一次循环。
 * 
 * 4.String[] str = new String[5];
 *   for(String u:str){
 *   	System.out.println(u);
 *   }
 *   
 * 5.Arrays类包含了用来操作数组的各种方法。Arrays.sort()对数组进行排序
 * 
 * 6.Overload指的是重载，它发生在一个类里，重载的要求是方法名要一样，参数列表不一样。Override指的是重写，发生在子父类中，重写要求方法头和参数列表完全一样，
 * Overloaded的方法可以改变返回值类型
 * 
 * 7.（1）输出结果为  Class A: a=11 d=2.0
 *    (2) 输出结果为  Class A: a=11 d=2.0
 *    				Class B: a=3.0 d=Java program.
 *    
 * 8.抽象类是指用abstract修饰类名，没有任何具体实例的类，抽象类是将类的共性提取出来，方便进行继承和扩展
 *
 * 9.final类是指这个类是终极的，不能被继承的。final方法可以使这个方法不被覆盖。
 * 
 * 10.Object类中的equals方法实际上用的是==，比较的是两个对象的地址值是否相同。hashCode方法是一个本地方法，返回的是将对象用哈希算法计算得出的值，实际上也就是内存地址值。
 * 
 * 11.throws关键字是用来声明异常的，是放在方法头中的，throw是抛出异常的关键字，是放在方法体中的。
 * 
 * 12.List是存取有序，有索引，能存放重复元素的集合，Set存取无序，无索引，不能存放重复元素
 * 
 * 13.Collection是一个集合接口，它提供了对几何对象进行基本操作的通用接口方法。
 * 	  Collections是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化。
 * 
 * 14.多态是指一件事情有多种解决方法，多态的三个表现特征是继承，重载，父类的引用指向子类的对象。
 * 
 * 15.byte（字节）型，长度为8位；char（字符）型，长度为16位，short（短整）型，长度为16位，int（整）型，长度为32位，long（长整）型，长度为64位，
 * 	   float(单精度浮点)型，长度为32位，double（双精度浮点）型，长度为64位。boolean（布尔）型 长度为1位
 * 
 * 16.面向对象的特征有封装，继承，多态，抽象，封装是指类将其数据域声明为私有的（private），外部类不能随意访问该类的数据域，只能通过该类提供的公共方法进行访问和修改。
 * 	  继承是指继承类拥有被继承类的特性和方法，继承能使类的功能和作用更加单一明确。
 * 		多态是指父类引用指向子类对象
 * 		抽象是指将类的共性提取出来，方便进行继承和扩展
 * 
 * 17.public修饰符的作用域是所有位置
 * 	  protected的作用域是本类，同一包下和子类
 * 	  默认的作用域是本类和同一包下
 *    private的作用域是只在本类中
 *    
 * 18.	int sum = 0;
 * 		for(int i=20;i>=0;i--){
 * 			sum = sum + ((100 - 5 * i) / 2 + 1);
 * 		}
 * 
 * 19.try/catch/finally语句块是为了捕获处理异常而存在的。
 * 		通常将可能会发生异常的代码块放入try块中，将处理异常的代码放入catch块中
 * 		finally块中放的是在任何情况下都会执行的代码。
 * 
 * 20.返回值是true
 * **/











public class Info {
	static List<Person> list = new ArrayList<Person>();
	
	public static void main(String[] args) {
		File file =new File("E:/info.txt");
		try {
			FileReader fr = new FileReader(file);
			BufferedReader br = new BufferedReader(fr);
			String line = br.readLine();
			
			int areaId = 0;
			int id = 0;
			int i = 0;
			int j = 0;
			int salary = 0;
			String name ;
			String area ;
			String sub;
			while(line!=null){
				//System.out.println("r");
				if(line.startsWith("#")){
					line = br.readLine();
					continue;
				}
				id = Integer.parseInt(line.substring(0,2));
				
				i = line.indexOf(",");
				j = line.indexOf(",", i+1);
				area = line.substring(i+1, j);
				
				i = line.indexOf(",", j+1);
				//j = line.indexOf(",", i+1);
				salary = Integer.parseInt(line.substring(j+1, i));
				
				//i = line.indexOf(",", j+1);
				j = line.indexOf(",", i+1);
				if(i+1==j)
					 areaId = 0;
				else
					areaId = Integer.parseInt(line.substring(i+1, j));
				
				if(line.charAt(line.length()-1)==',')
					name = null;
				name = line.substring(j+1, line.length());
				
				list.add(new Person(id,area,salary,areaId,name));
				line = br.readLine();
			}
			br.close();
		} catch (FileNotFoundException e) {

			e.printStackTrace();
		} catch (IOException e) {

			e.printStackTrace();
		}
		while(true){
		System.out.println("请输入指令： ");
		Scanner input = new Scanner(System.in);
		//input.useDelimiter("\n");
		String string = input.next();
		if(string.equals("exit"))
			exit();
		else if(string.equals("help"))
			help();
		else if(string.contains("ls"))
			ls(string);
		else if(string.contains("name")&&string.contains("find"))
			findName(string);
		else if(string.contains("find")&&string.contains("salary"))
			findSalary(string);
		else if(string.contains("sort")&&string.contains("name"))
			sorts(string);
		else if(string.contains("sort")&&string.contains("salary"))
			sorts(string);
		
		else 
			sort();
		}
	}
	
	public static void exit(){
		System.exit(0);
	}
	
	public static void help(){
		System.out.println("1.输 入\"exit\" 可以退出程序\r\n"+

			"2.输 入\"help\" 可以输出所有可用命令及命令的使用规则。\r\n"+

			"3.输 入\"ls [-all] [ID]\" 可以输出 [ 对应ID ] 记录的基本[详细]信息。-all, ID 参数为可选项。例如： ls -all 输出txt总的全部信息， ls 01 输出01的信息， ls -all 02 输出02的信息及子地区信息。\r\n"+

			"4.输 入find [-name|-salary] [value] 可以搜索并打印按 [ 名字|平均收 入 ] 为条件的记录。-name或者-salary，以及value不能为空。例如： find -name 江 查找名字中带有”江“字的所有地区， find -salary 3000 查找平均收 入 高于3000之间的地区。\r\n"+

			"5.find -salary 搜索条件的取值必须符合“全数字”或者“数字~数字”的格式。当取值为全数字时，按大于等于条件搜索。当取值为“数字 ~ 数字”时，按区间搜索，包含相等的值。例如： find -salary 3000~4000 。\r\n"+

			"6.输 入\"sort [-name|-salary]\" 可以输出按 [名字|平均收 入] 排序后的基本信息。 -name, -salary为可选项，默认按 ID 排序。例如： sort -name ， sort -salary 。"
			);
	}
	
	public static void ls(String ls){
		if(ls.contains("all")){
			if(ls.substring(ls.length()-2, ls.length()).equals("ll")){
				Iterator<Person> it = list.iterator();
				while(it.hasNext()){
					System.out.println(it.next());
				}
			}else{
				int i = Integer.parseInt(ls.substring(ls.length()-2, ls.length()));
				int j = 0;
				for(Person p:list){
					if(p.getId()==i)
						j = p.getAreaId();
				}
				for(Person p:list){
					if(p.getAreaId()<=j)
						System.out.println(p);
				}
			}
			
		}else{
		
			int k = Integer.parseInt(ls.substring(ls.length()-2, ls.length()));
			int v = 0;
			
			for(Person p:list){
				if(p.getId()==k)
					System.out.println(p);;
			}
		
		
		}
	}
	
	public static void findName(String name){
		System.out.println("r");
		if(name.substring(name.length()-2,name.length()).equals("me"))
			System.out.println("Error:没有value值");
		
		int i = name.indexOf("name");
		String s = name.substring(i+5, name.length());
		
		for(Person p:list){
			if(p.getAreaName().contains(s))
				System.out.println(p);
		}
	}
	
	public static void findSalary(String name){
		if(name.substring(name.length()-2, name.length()).equals("ry"))
			System.out.println("Error:没有value值");
		
		int i = name.indexOf("salary");
		
		if(name.contains("~")){
			int index = name.indexOf("~");
			int front = Integer.parseInt(name.substring(i+7, index));
			int behind = Integer.parseInt(name.substring(index+1, name.length()));
			
			for(Person p:list){
				if(p.getSalary()>=front && p.getSalary()<=behind)
					System.out.println(p);
			}
		}else{
		
			int s = Integer.parseInt(name.substring(i+7, name.length()));
			
			for(Person p:list){
				if(p.getSalary()>s)
					System.out.println(p);
			}
		}
	}
	
	public static void sort(){
		for(Person p:list){
			System.out.println(p);
		}
	}
	
	public static void sorts(String s){
		if(s.contains("name")){			
			Comparator c = Collator.getInstance(java.util.Locale.CHINA);
			Set<String> set = new TreeSet<String>(c);
			for(Person p:list){
				set.add(p.getPersonName());
			}
			
			for(String t:set){
				for(Person p:list){
					if(p.getPersonName().equals(t))
						System.out.println(p);
				}
			}
		}
		
		if(s.contains("salary")){
			Set<Integer> set = new TreeSet<Integer>();
			for(Person p: list){
				set.add(p.getSalary());
			}
			
			for(Integer i:set){
				for(Person p:list){
					if(p.getSalary()==i)
						System.out.println(p);
				}
			}
		}
	}
	
	
	
	

}
